home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / sunrpc / sched.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  7.7 KB  |  260 lines
  1. /*
  2.  * linux/include/linux/sunrpc/sched.h
  3.  *
  4.  * Scheduling primitives for kernel Sun RPC.
  5.  *
  6.  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9. #ifndef _LINUX_SUNRPC_SCHED_H_
  10. #define _LINUX_SUNRPC_SCHED_H_
  11.  
  12. #include <linux/timer.h>
  13. #include <linux/sunrpc/types.h>
  14. #include <linux/spinlock.h>
  15. #include <linux/wait.h>
  16. #include <linux/workqueue.h>
  17. #include <linux/sunrpc/xdr.h>
  18.  
  19. /*
  20.  * This is the actual RPC procedure call info.
  21.  */
  22. struct rpc_procinfo;
  23. struct rpc_message {
  24.     struct rpc_procinfo *    rpc_proc;    /* Procedure information */
  25.     void *            rpc_argp;    /* Arguments */
  26.     void *            rpc_resp;    /* Result */
  27.     struct rpc_cred *    rpc_cred;    /* Credentials */
  28. };
  29.  
  30. struct rpc_call_ops;
  31. struct rpc_wait_queue;
  32. struct rpc_wait {
  33.     struct list_head    list;        /* wait queue links */
  34.     struct list_head    links;        /* Links to related tasks */
  35.     struct list_head    timer_list;    /* Timer list */
  36.     unsigned long        expires;
  37. };
  38.  
  39. /*
  40.  * This is the RPC task struct
  41.  */
  42. struct rpc_task {
  43. #ifdef RPC_DEBUG
  44.     unsigned long        tk_magic;    /* 0xf00baa */
  45. #endif
  46.     atomic_t        tk_count;    /* Reference count */
  47.     struct list_head    tk_task;    /* global list of tasks */
  48.     struct rpc_clnt *    tk_client;    /* RPC client */
  49.     struct rpc_rqst *    tk_rqstp;    /* RPC request */
  50.     int            tk_status;    /* result of last operation */
  51.  
  52.     /*
  53.      * RPC call state
  54.      */
  55.     struct rpc_message    tk_msg;        /* RPC call info */
  56.     __u8            tk_garb_retry;
  57.     __u8            tk_cred_retry;
  58.  
  59.     /*
  60.      * callback    to be executed after waking up
  61.      * action    next procedure for async tasks
  62.      * tk_ops    caller callbacks
  63.      */
  64.     void            (*tk_callback)(struct rpc_task *);
  65.     void            (*tk_action)(struct rpc_task *);
  66.     const struct rpc_call_ops *tk_ops;
  67.     void *            tk_calldata;
  68.  
  69.     unsigned long        tk_timeout;    /* timeout for rpc_sleep() */
  70.     unsigned short        tk_flags;    /* misc flags */
  71.     unsigned long        tk_runstate;    /* Task run status */
  72.     struct workqueue_struct    *tk_workqueue;    /* Normally rpciod, but could
  73.                          * be any workqueue
  74.                          */
  75.     struct rpc_wait_queue     *tk_waitqueue;    /* RPC wait queue we're on */
  76.     union {
  77.         struct work_struct    tk_work;    /* Async task work queue */
  78.         struct rpc_wait        tk_wait;    /* RPC wait */
  79.     } u;
  80.  
  81.     unsigned short        tk_timeouts;    /* maj timeouts */
  82.     size_t            tk_bytes_sent;    /* total bytes sent */
  83.     unsigned long        tk_start;    /* RPC task init timestamp */
  84.     long            tk_rtt;        /* round-trip time (jiffies) */
  85.  
  86.     pid_t            tk_owner;    /* Process id for batching tasks */
  87.     unsigned char        tk_priority : 2;/* Task priority */
  88.  
  89. #ifdef RPC_DEBUG
  90.     unsigned short        tk_pid;        /* debugging aid */
  91. #endif
  92. };
  93. #define tk_xprt            tk_client->cl_xprt
  94.  
  95. /* support walking a list of tasks on a wait queue */
  96. #define    task_for_each(task, pos, head) \
  97.     list_for_each(pos, head) \
  98.         if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1)
  99.  
  100. #define    task_for_first(task, head) \
  101.     if (!list_empty(head) &&  \
  102.         ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))
  103.  
  104. typedef void            (*rpc_action)(struct rpc_task *);
  105.  
  106. struct rpc_call_ops {
  107.     void (*rpc_call_prepare)(struct rpc_task *, void *);
  108.     void (*rpc_call_done)(struct rpc_task *, void *);
  109.     void (*rpc_release)(void *);
  110. };
  111.  
  112. struct rpc_task_setup {
  113.     struct rpc_task *task;
  114.     struct rpc_clnt *rpc_client;
  115.     const struct rpc_message *rpc_message;
  116.     const struct rpc_call_ops *callback_ops;
  117.     void *callback_data;
  118.     struct workqueue_struct *workqueue;
  119.     unsigned short flags;
  120.     signed char priority;
  121. };
  122.  
  123. /*
  124.  * RPC task flags
  125.  */
  126. #define RPC_TASK_ASYNC        0x0001        /* is an async task */
  127. #define RPC_TASK_SWAPPER    0x0002        /* is swapping in/out */
  128. #define RPC_CALL_MAJORSEEN    0x0020        /* major timeout seen */
  129. #define RPC_TASK_ROOTCREDS    0x0040        /* force root creds */
  130. #define RPC_TASK_DYNAMIC    0x0080        /* task was kmalloc'ed */
  131. #define RPC_TASK_KILLED        0x0100        /* task was killed */
  132. #define RPC_TASK_SOFT        0x0200        /* Use soft timeouts */
  133.  
  134. #define RPC_IS_ASYNC(t)        ((t)->tk_flags & RPC_TASK_ASYNC)
  135. #define RPC_IS_SWAPPER(t)    ((t)->tk_flags & RPC_TASK_SWAPPER)
  136. #define RPC_DO_ROOTOVERRIDE(t)    ((t)->tk_flags & RPC_TASK_ROOTCREDS)
  137. #define RPC_ASSASSINATED(t)    ((t)->tk_flags & RPC_TASK_KILLED)
  138. #define RPC_IS_SOFT(t)        ((t)->tk_flags & RPC_TASK_SOFT)
  139.  
  140. #define RPC_TASK_RUNNING    0
  141. #define RPC_TASK_QUEUED        1
  142. #define RPC_TASK_ACTIVE        2
  143.  
  144. #define RPC_IS_RUNNING(t)    test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
  145. #define rpc_set_running(t)    set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
  146. #define rpc_test_and_set_running(t) \
  147.                 test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
  148. #define rpc_clear_running(t)    \
  149.     do { \
  150.         smp_mb__before_clear_bit(); \
  151.         clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \
  152.         smp_mb__after_clear_bit(); \
  153.     } while (0)
  154.  
  155. #define RPC_IS_QUEUED(t)    test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)
  156. #define rpc_set_queued(t)    set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate)
  157. #define rpc_clear_queued(t)    \
  158.     do { \
  159.         smp_mb__before_clear_bit(); \
  160.         clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \
  161.         smp_mb__after_clear_bit(); \
  162.     } while (0)
  163.  
  164. #define RPC_IS_ACTIVATED(t)    test_bit(RPC_TASK_ACTIVE, &(t)->tk_runstate)
  165.  
  166. /*
  167.  * Task priorities.
  168.  * Note: if you change these, you must also change
  169.  * the task initialization definitions below.
  170.  */
  171. #define RPC_PRIORITY_LOW    (-1)
  172. #define RPC_PRIORITY_NORMAL    (0)
  173. #define RPC_PRIORITY_HIGH    (1)
  174. #define RPC_NR_PRIORITY        (1 + RPC_PRIORITY_HIGH - RPC_PRIORITY_LOW)
  175.  
  176. struct rpc_timer {
  177.     struct timer_list timer;
  178.     struct list_head list;
  179.     unsigned long expires;
  180. };
  181.  
  182. /*
  183.  * RPC synchronization objects
  184.  */
  185. struct rpc_wait_queue {
  186.     spinlock_t        lock;
  187.     struct list_head    tasks[RPC_NR_PRIORITY];    /* task queue for each priority level */
  188.     pid_t            owner;            /* process id of last task serviced */
  189.     unsigned char        maxpriority;        /* maximum priority (0 if queue is not a priority queue) */
  190.     unsigned char        priority;        /* current priority */
  191.     unsigned char        count;            /* # task groups remaining serviced so far */
  192.     unsigned char        nr;            /* # tasks remaining for cookie */
  193.     unsigned short        qlen;            /* total # tasks waiting in queue */
  194.     struct rpc_timer    timer_list;
  195. #ifdef RPC_DEBUG
  196.     const char *        name;
  197. #endif
  198. };
  199.  
  200. /*
  201.  * This is the # requests to send consecutively
  202.  * from a single cookie.  The aim is to improve
  203.  * performance of NFS operations such as read/write.
  204.  */
  205. #define RPC_BATCH_COUNT            16
  206. #define RPC_IS_PRIORITY(q)        ((q)->maxpriority > 0)
  207.  
  208. /*
  209.  * Function prototypes
  210.  */
  211. struct rpc_task *rpc_new_task(const struct rpc_task_setup *);
  212. struct rpc_task *rpc_run_task(const struct rpc_task_setup *);
  213. void        rpc_put_task(struct rpc_task *);
  214. void        rpc_exit_task(struct rpc_task *);
  215. void        rpc_release_calldata(const struct rpc_call_ops *, void *);
  216. void        rpc_killall_tasks(struct rpc_clnt *);
  217. void        rpc_execute(struct rpc_task *);
  218. void        rpc_init_priority_wait_queue(struct rpc_wait_queue *, const char *);
  219. void        rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
  220. void        rpc_destroy_wait_queue(struct rpc_wait_queue *);
  221. void        rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
  222.                     rpc_action action);
  223. void        rpc_wake_up_queued_task(struct rpc_wait_queue *,
  224.                     struct rpc_task *);
  225. void        rpc_wake_up(struct rpc_wait_queue *);
  226. struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
  227. void        rpc_wake_up_status(struct rpc_wait_queue *, int);
  228. void        rpc_delay(struct rpc_task *, unsigned long);
  229. void *        rpc_malloc(struct rpc_task *, size_t);
  230. void        rpc_free(void *);
  231. int        rpciod_up(void);
  232. void        rpciod_down(void);
  233. int        __rpc_wait_for_completion_task(struct rpc_task *task, int (*)(void *));
  234. #ifdef RPC_DEBUG
  235. void        rpc_show_tasks(void);
  236. #endif
  237. int        rpc_init_mempool(void);
  238. void        rpc_destroy_mempool(void);
  239. extern struct workqueue_struct *rpciod_workqueue;
  240.  
  241. static inline void rpc_exit(struct rpc_task *task, int status)
  242. {
  243.     task->tk_status = status;
  244.     task->tk_action = rpc_exit_task;
  245. }
  246.  
  247. static inline int rpc_wait_for_completion_task(struct rpc_task *task)
  248. {
  249.     return __rpc_wait_for_completion_task(task, NULL);
  250. }
  251.  
  252. #ifdef RPC_DEBUG
  253. static inline const char * rpc_qname(struct rpc_wait_queue *q)
  254. {
  255.     return ((q && q->name) ? q->name : "unknown");
  256. }
  257. #endif
  258.  
  259. #endif /* _LINUX_SUNRPC_SCHED_H_ */
  260.